--- /dev/null
+/*
+ * XenoDomainBuilder, copyright (c) Boris Dragovic, bd240@cl.cam.ac.uk
+ * This code is released under terms and conditions of GNU GPL :).
+ * Usage: <executable> <mem_kb> <os image> <num_vifs>
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "hypervisor_defs.h"
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+#include "mem_defs.h"
+
+#define PERR_STRING "Xeno Domain Builder"
+
+#define GUEST_SIG "XenoGues"
+#define SIG_LEN 8
+
+#define L1_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_USER|_PAGE_ACCESSED)
+#define L2_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_USER|_PAGE_ACCESSED|_PAGE_DIRTY)
+
+/* standardized error reporting function */
+static void dberr(char *msg)
+{
+ printf("%s: %s\n", PERR_STRING, msg);
+}
+
+/* status reporting function */
+static void dbstatus(char * msg)
+{
+ printf("Domain Builder: %s\n", msg);
+}
+
+/* clean up domain's memory allocations */
+static void dom_mem_cleanup(dom_mem_t * dom_mem)
+{
+ char mem_path[MAX_PATH];
+ int mem_fd;
+
+ /* open the domain's /proc mem interface */
+ sprintf(mem_path, "%s%s%s%s%d%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_PREFIX, dom_mem->domain, "/", PROC_DOM_MEM);
+
+ mem_fd = open(mem_path, O_WRONLY);
+ if(mem_fd < 0){
+ perror(PERR_STRING);
+ }
+
+ if(write(mem_fd, (dom_mem_t *)dom_mem, sizeof(dom_mem_t)) < 0){
+ dbstatus("Error unmapping domain's memory.\n");
+ }
+
+ close(mem_fd);
+}
+
+/* ask dom0 to export domains memory through /proc */
+static int setup_dom_memmap(unsigned long pfn, int pages, int dom)
+{
+ char cmd_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+
+ dop.cmd = MAP_DOM_MEM;
+ dop.u.dommem.start_pfn = pfn;
+ dop.u.dommem.tot_pages = pages;
+ dop.u.dommem.domain = dom;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+/* request the actual mapping from dom0 */
+static unsigned long get_vaddr(unsigned int dom)
+{
+ char mem_path[MAX_PATH];
+ unsigned long addr;
+ int mem_fd;
+
+ /* open the domain's /proc mem interface */
+ sprintf(mem_path, "%s%s%s%s%d%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_PREFIX, dom, "/", PROC_DOM_MEM);
+
+ mem_fd = open(mem_path, O_RDONLY);
+ if(mem_fd < 0){
+ perror(PERR_STRING);
+ return 0;
+ }
+
+ /* get virtual address of mapped region */
+ read(mem_fd, &addr, sizeof(addr));
+
+ close(mem_fd);
+
+ return addr;
+}
+
+static int map_dom_mem(unsigned long pfn, int pages, int dom,
+ dom_mem_t * dom_mem)
+{
+
+ if(setup_dom_memmap(pfn, pages, dom)){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ dom_mem->domain = dom;
+ dom_mem->start_pfn = pfn;
+ dom_mem->tot_pages = pages;
+ if((dom_mem->vaddr = get_vaddr(dom)) == 0){
+ dberr("Error mapping dom memory.");
+ return -1;
+ }
+
+ return 0;
+}
+
+/* create new domain */
+static dom0_newdomain_t * create_new_domain(long req_mem)
+{
+ dom0_newdomain_t * dom_data;
+ char cmd_path[MAX_PATH];
+ char dom_id_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+ int id_fd;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ perror(PERR_STRING);
+ return 0;
+ }
+
+ dop.cmd = DOM0_NEWDOMAIN;
+ dop.u.newdomain.memory_kb = req_mem;
+
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ sprintf(dom_id_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_DATA);
+ while((id_fd = open(dom_id_path, O_RDONLY)) < 0){}
+ dom_data = (dom0_newdomain_t *)malloc(sizeof(dom0_newdomain_t));
+ read(id_fd, dom_data, sizeof(dom0_newdomain_t));
+ close(id_fd);
+
+ sprintf(cmd_path, "Reserved %ld kbytes memory and assigned id %d to the"
+ "new domain.", req_mem, dom_data->domain);
+ dbstatus(cmd_path);
+
+ return dom_data;
+}
+
+/* open kernel image and do some sanity checks */
+static int do_kernel_chcks(char *image, long dom_size,
+ unsigned long * load_addr, size_t * ksize)
+{
+ char signature[8];
+ char status[MAX_PATH];
+ struct stat stat;
+ int fd;
+ int ret;
+
+ fd = open(image, O_RDONLY);
+ if(fd < 0){
+ perror(PERR_STRING);
+ ret = -1;
+ goto out;
+ }
+
+ if(fstat(fd, &stat) < 0){
+ perror(PERR_STRING);
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+
+ if(stat.st_size > (dom_size << 10)){
+ sprintf(status, "Kernel image size %ld larger than requested "
+ "domain size %ld\n Terminated.\n", stat.st_size, dom_size);
+ dberr(status);
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+ *ksize = stat.st_size - SIG_LEN;
+
+ read(fd, signature, SIG_LEN);
+ if(strncmp(signature, GUEST_SIG, SIG_LEN)){
+ dberr("Kernel image does not contain required signature. "
+ "Terminating.\n");
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+
+ read(fd, load_addr, sizeof(unsigned long));
+
+ sprintf(status, "Kernel image %s valid, kernel virtual load address %lx",
+ image, *load_addr);
+ dbstatus(status);
+
+ ret = fd;
+
+out:
+ return ret;
+}
+
+/* this is the main guestos setup function,
+ * returnes domain descriptor structure to be used when launching
+ * the domain by hypervisor to do some last minute initialization.
+ * page table initialization is done by making a list of page table
+ * requests that are handeled by the hypervisor in the ordinary
+ * manner. this way, many potentially messy things are avoided...
+ */
+static dom_meminfo_t * setup_guestos(int dom, int kernel_fd,
+ unsigned long virt_load_addr, size_t ksize, dom_mem_t *dom_mem)
+{
+ dom_meminfo_t * meminfo = (dom_meminfo_t *)malloc(sizeof(dom_meminfo_t));
+ unsigned long * page_array = (unsigned long *)(dom_mem->vaddr);
+ page_update_request_t * pgt_updates = (page_update_request_t *)
+ (dom_mem->vaddr + ((ksize + (PAGE_SIZE-1)) & PAGE_MASK));
+ dom_mem_t mem_map;
+ dom_meminfo_t * ret = NULL;
+ int alloc_index = dom_mem->tot_pages - 1, num_pt_pages;
+ unsigned long l2tab;
+ unsigned long l1tab = 0;
+ unsigned long num_pgt_updates = 0;
+ unsigned long pgt_update_arr = (unsigned long)pgt_updates;
+ unsigned long count, pt_start;
+
+ /* Count bottom-level PTs. Round up to a whole PT. */
+ num_pt_pages =
+ (l1_table_offset(virt_load_addr) + dom_mem->tot_pages + 1023) / 1024;
+ /* We must also count the page directory. */
+ num_pt_pages++;
+
+ /* Index of first PT page. */
+ pt_start = dom_mem->tot_pages - num_pt_pages;
+
+ /* first allocate page for page dir. allocation goes backwards from the
+ * end of the allocated physical address space.
+ */
+ l2tab = *(page_array + alloc_index) << PAGE_SHIFT;
+ alloc_index--;
+ meminfo->l2_pgt_addr = l2tab;
+ meminfo->virt_shinfo_addr = virt_load_addr + nr_2_page(dom_mem->tot_pages);
+ count = ((unsigned long)pgt_updates - (unsigned long)(dom_mem->vaddr))
+ >> PAGE_SHIFT;
+
+ /* zero out l2 page */
+ if(map_dom_mem(l2tab >> PAGE_SHIFT, 1, dom_mem->domain, &mem_map)){
+ dberr("Unable to map l2 page into Domain Builder.");
+ goto out;
+ }
+ memset((void *)mem_map.vaddr, 0, PAGE_SIZE);
+ dom_mem_cleanup(&mem_map);
+
+ /* pin down l2tab addr as page dir page - causes hypervisor to provide
+ * correct protection for the page
+ */
+ pgt_updates->ptr = l2tab | PGREQ_EXTENDED_COMMAND;
+ pgt_updates->val = PGEXT_PIN_L2_TABLE;
+ pgt_updates++;
+ num_pgt_updates++;
+
+ /* this loop initializes page tables and does one extra entry
+ * to be used by the shared info page. shared info is not in
+ * the domains physical address space and is not owned by the
+ * domain.
+ */
+ l2tab += l2_table_offset(virt_load_addr) * sizeof(l2_pgentry_t);
+ for(count = 0;
+ count < dom_mem->tot_pages + 1;
+ count++){
+
+ if(!((unsigned long)l1tab & (PAGE_SIZE-1))){
+ l1tab = *(page_array + alloc_index) << PAGE_SHIFT;
+ alloc_index--;
+
+ /* zero out l1 page */
+ if(map_dom_mem(l1tab >> PAGE_SHIFT, 1, dom_mem->domain, &mem_map)){
+ dberr("Unable to map l1 page into Domain Builder.");
+ goto out;
+ }
+ memset((void *)mem_map.vaddr, 0, PAGE_SIZE);
+ dom_mem_cleanup(&mem_map);
+
+ l1tab += l1_table_offset(virt_load_addr + nr_2_page(count))
+ * sizeof(l1_pgentry_t);
+
+ /* make apropriate entry in the page directory */
+ pgt_updates->ptr = l2tab;
+ pgt_updates->val = l1tab | L2_PROT;
+ pgt_updates++;
+ num_pgt_updates++;
+ l2tab += sizeof(l2_pgentry_t);
+ }
+
+ if ( count < pt_start )
+ {
+ pgt_updates->ptr = l1tab;
+ pgt_updates->val = (*(page_array + count) << PAGE_SHIFT) | L1_PROT;
+ pgt_updates++;
+ num_pgt_updates++;
+ l1tab += sizeof(l1_pgentry_t);
+ }
+ else
+ {
+ pgt_updates->ptr = l1tab;
+ pgt_updates->val =
+ ((*(page_array + count) << PAGE_SHIFT) | L1_PROT) & ~_PAGE_RW;
+ pgt_updates++;
+ num_pgt_updates++;
+ l1tab += sizeof(l1_pgentry_t);
+ }
+
+ pgt_updates->ptr =
+ (*(page_array + count) << PAGE_SHIFT) | PGREQ_MPT_UPDATE;
+ pgt_updates->val = count;
+ pgt_updates++;
+ num_pgt_updates++;
+ }
+
+ meminfo->virt_startinfo_addr = virt_load_addr + nr_2_page(alloc_index - 1);
+ meminfo->domain = dom;
+
+ /* copy the guest os image */
+ if(!(read(kernel_fd, (char *)dom_mem->vaddr, ksize) > 0)){
+ dberr("Error reading kernel image, could not"
+ " read the whole image. Terminating.\n");
+ goto out;
+ }
+
+ {
+ dom0_op_t pgupdate_req;
+ char cmd_path[MAX_PATH];
+ int cmd_fd;
+
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ if ( (cmd_fd = open(cmd_path, O_WRONLY)) < 0 ) goto out;
+
+ pgupdate_req.cmd = DO_PGUPDATES;
+ pgupdate_req.u.pgupdate.pgt_update_arr = pgt_update_arr;
+ pgupdate_req.u.pgupdate.num_pgt_updates = num_pgt_updates;
+
+ write(cmd_fd, &pgupdate_req, sizeof(dom0_op_t));
+ close(cmd_fd);
+ }
+
+ ret = meminfo;
+out:
+
+ return ret;
+}
+
+static int launch_domain(dom_meminfo_t * meminfo)
+{
+ char cmd_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ dop.cmd = DOM0_STARTDOM;
+ memcpy(&dop.u.meminfo, meminfo, sizeof(dom_meminfo_t));
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+
+ dbstatus("Launched the new domain!");
+
+ close(cmd_fd);
+}
+
+int main(int argc, char **argv)
+{
+
+ dom0_newdomain_t * dom_data;
+ dom_mem_t dom_os_image;
+ dom_mem_t dom_pgt;
+ dom_meminfo_t * meminfo;
+ size_t ksize;
+ unsigned long load_addr;
+ char status[1024];
+ int kernel_fd;
+ int count;
+ int cmd_len;
+ int ret = 0;
+
+ unsigned long addr;
+
+ if(argc < 4){
+ dberr("Usage: dom_builder <kbytes_mem> <image> <num_vifs> "
+ "<boot_params>\n");
+ ret = -1;
+ goto out;
+ }
+
+ /* create new domain and set up all the neccessary mappings */
+
+ kernel_fd = do_kernel_chcks(argv[2], atol(argv[1]), &load_addr, &ksize);
+ if(kernel_fd < 0){
+ ret = -1;
+ goto out;
+ }
+
+ /* request the creation of new domain */
+ dom_data = create_new_domain(atol(argv[1]));
+ if(dom_data == 0){
+ ret = -1;
+ goto out;
+ }
+
+ /* map domain's memory */
+ if(map_dom_mem(dom_data->pg_head, dom_data->memory_kb >> (PAGE_SHIFT - 10),
+ dom_data->domain, &dom_os_image)){
+ ret = -1;
+ goto out;
+ }
+
+ /* the following code does the actual domain building */
+ meminfo = setup_guestos(dom_data->domain, kernel_fd, load_addr, ksize,
+ &dom_os_image);
+ if(meminfo == NULL){
+ printf("Domain Builder: debug: meminfo NULL\n");
+ ret = -1;
+ dom_mem_cleanup(&dom_os_image);
+ goto out;
+ }
+
+ dom_mem_cleanup(&dom_os_image);
+
+ meminfo->virt_load_addr = load_addr;
+ meminfo->num_vifs = atoi(argv[3]);
+ meminfo->cmd_line[0] = '\0';
+ cmd_len = 0;
+ for(count = 4; count < argc; count++){
+ if(cmd_len + strlen(argv[count]) > MAX_CMD_LEN - 1){
+ dberr("Size of image boot params too big!\n");
+ break;
+ }
+ strcat(meminfo->cmd_line, argv[count]);
+ strcat(meminfo->cmd_line, " ");
+ cmd_len += strlen(argv[count] + 1);
+ }
+
+ sprintf(status,
+ "About to launch new domain %d with folowing parameters:\n"
+ " * page table base: %lx \n * load address: %lx \n"
+ " * shared info address: %lx \n * start info address: %lx \n"
+ " * number of vifs: %d \n * cmd line: %s \n", meminfo->domain,
+ meminfo->l2_pgt_addr, meminfo->virt_load_addr,
+ meminfo->virt_shinfo_addr, meminfo->virt_startinfo_addr,
+ meminfo->num_vifs, meminfo->cmd_line);
+ dbstatus(status);
+
+ /* and launch the domain */
+ if(launch_domain(meminfo) != 0)
+ ret = -1;
+
+ free(meminfo);
+out:
+ return ret;
+}
projects / xen.git / commitdiff